# -*- coding: UTF-8 -*-
"Les balises personnalisées du système de commentaires"

from django.core import template
from django.core.exceptions import ObjectDoesNotExist
from django.models.comments import comments, freecomments
from django.models.core import contenttypes
import re

COMMENT_FORM = '''
{% if display_form %}
<form {% if photos_optional or photos_required %}enctype="multipart/form-data" {% endif %}action="/comments/post/" method="post">

{% if user.is_anonymous %}
<p>Nom d'utilisateur : <input type="text" name="username" id="id_username" /><br />Mot de passe : <input type="password" name="password" id="id_password" /> (<a href="/accounts/password_reset/">Avez-vous oublié votre mot de passe?</a>)</p>
{% else %}
<p>Nom d'utilisateur : <strong>{{ user.username }}</strong> (<a href="/accounts/logout/">Déconnexion</a>)</p>
{% endif %}

{% if ratings_optional or ratings_required %}
<p>Notes ({% if ratings_required %}obligatoires{% else %}facultatives{% endif %}) :</p>
<table>
<tr><th>&nbsp;</th>{% for value in rating_range %}<th>{{ value }}</th>{% endfor %}</tr>
{% for rating in rating_choices %}
<tr><th>{{ rating }}</th>{% for value in rating_range %}<th><input type="radio" name="rating{{ forloop.parentloop.counter }}" value="{{ value }}" /></th>{% endfor %}</tr>
{% endfor %}
</table>
<input type="hidden" name="rating_options" value="{{ rating_options }}" />
{% endif %}

{% if photos_optional or photos_required %}
<p>Postez une photo ({% if photos_required %}obligatoire{% else %}facultatif{% endif %}) : <input type="file" name="photo" /></p>
<input type="hidden" name="photo_options" value="{{ photo_options }}" />
{% endif %}

<p>Commentaire :<br /><textarea name="comment" id="id_comment" rows="10" cols="60"></textarea></p>

<input type="hidden" name="options" value="{{ options }}" />
<input type="hidden" name="target" value="{{ target }}" />
<input type="hidden" name="gonzo" value="{{ hash }}" />
<p><input type="submit" name="preview" value="Prévisualiser commentaire" /></p>
</form>
{% endif %}
'''

FREE_COMMENT_FORM = '''
{% if display_form %}
<form enctype="multipart/form-data" action="/comments/postfree/" method="post">
<p>Votre nom : <input type="text" id="id_person_name" name="person_name" /></p>
<p>Commentaire :<br /><textarea name="comment" id="id_comment" rows="10" cols="60"></textarea></p>
<input type="hidden" name="options" value="{{ options }}" />
<input type="hidden" name="target" value="{{ target }}" />
<input type="hidden" name="gonzo" value="{{ hash }}" />
<p><input type="submit" name="preview" value="Prévisualiser commentaire" /></p>
</form>
{% endif %}
'''

class CommentFormNode(template.Node):
    def __init__(self, content_type, obj_id_lookup_var, obj_id, free,
        photos_optional=False, photos_required=False, photo_options='',
        ratings_optional=False, ratings_required=False, rating_options='',
        is_public=True):
        self.content_type = content_type
        self.obj_id_lookup_var, self.obj_id, self.free = obj_id_lookup_var, obj_id, free
        self.photos_optional, self.photos_required = photos_optional, photos_required
        self.ratings_optional, self.ratings_required = ratings_optional, ratings_required
        self.photo_options, self.rating_options = photo_options, rating_options
        self.is_public = is_public

    def render(self, context):
        from django.utils.text import normalize_newlines
        import base64
        context.push()
        if self.obj_id_lookup_var is not None:
            try:
                self.obj_id = template.resolve_variable(self.obj_id_lookup_var, context)
            except template.VariableDoesNotExist:
                return ''
            # On vérifie que l'identifiant de l'objet concerné par le commentaire
            # est un identifiant valide pour le type de contenu correspondant. On
            # n'a à effectuer cette vérification que si l'argument obj_id_lookup_var
            # est spécifié, car dans les autres cas la fonction do_comment_form()
            # se charge de la vérification des identifiants d'objet codés en dur.
            try:
                self.content_type.get_object_for_this_type(id__exact=self.obj_id)
            except ObjectDoesNotExist:
                context['display_form'] = False
            else:
                context['display_form'] = True
        context['target'] = '%s:%s' % (self.content_type.id, self.obj_id)
        options = []
        for var, abbr in (('photos_required', comments.PHOTOS_REQUIRED),
                          ('photos_optional', comments.PHOTOS_OPTIONAL),
                          ('ratings_required', comments.RATINGS_REQUIRED),
                          ('ratings_optional', comments.RATINGS_OPTIONAL),
                          ('is_public', comments.IS_PUBLIC)):
            context[var] = getattr(self, var)
            if getattr(self, var):
                options.append(abbr)
        context['options'] = ','.join(options)
        if self.free:
            context['hash'] = comments.get_security_hash(context['options'], '', '', context['target'])
            default_form = FREE_COMMENT_FORM
        else:
            context['photo_options'] = self.photo_options
            context['rating_options'] = normalize_newlines(base64.encodestring(self.rating_options).strip())
            if self.rating_options:
                context['rating_range'], context['rating_choices'] = comments.get_rating_options(self.rating_options)
            context['hash'] = comments.get_security_hash(context['options'], context['photo_options'], context['rating_options'], context['target'])
            default_form = COMMENT_FORM
        output = template.Template(default_form).render(context)
        context.pop()
        return output

class CommentCountNode(template.Node):
    def __init__(self, package, module, context_var_name, obj_id, var_name, free):
        self.package, self.module = package, module
        self.context_var_name, self.obj_id = context_var_name, obj_id
        self.var_name, self.free = var_name, free

    def render(self, context):
        from django.conf.settings import SITE_ID
        get_count_function = self.free and freecomments.get_count or comments.get_count
        if self.context_var_name is not None:
            self.obj_id = template.resolve_variable(self.context_var_name, context)
        comment_count = get_count_function(object_id__exact=self.obj_id,
            content_type__package__label__exact=self.package,
            content_type__python_module_name__exact=self.module, site_id__exact=SITE_ID)
        context[self.var_name] = comment_count
        return ''

class CommentListNode(template.Node):
    def __init__(self, package, module, context_var_name, obj_id, var_name, free):
        self.package, self.module = package, module
        self.context_var_name, self.obj_id = context_var_name, obj_id
        self.var_name, self.free = var_name, free

    def render(self, context):
        from django.conf.settings import COMMENTS_BANNED_USERS_GROUP, SITE_ID
        get_list_function = self.free and freecomments.get_list or comments.get_list_with_karma
        if self.context_var_name is not None:
            try:
                self.obj_id = template.resolve_variable(self.context_var_name, context)
            except template.VariableDoesNotExist:
                return ''
        kwargs = {
            'object_id__exact': self.obj_id,
            'content_type__package__label__exact': self.package,
            'content_type__python_module_name__exact': self.module,
            'site_id__exact': SITE_ID,
            'select_related': True,
            'order_by': (('submit_date', 'ASC'),),
        }
        if not self.free and COMMENTS_BANNED_USERS_GROUP:
            kwargs['select'] = {'is_hidden': 'user_id IN (SELECT user_id FROM auth_users_groups WHERE group_id = %s)' % COMMENTS_BANNED_USERS_GROUP}
        comment_list = get_list_function(**kwargs)

        if not self.free:
            if context.has_key('user') and not context['user'].is_anonymous():
                user_id = context['user'].id
                context['user_can_moderate_comments'] = comments.user_is_moderator(context['user'])
            else:
                user_id = None
                context['user_can_moderate_comments'] = False
            # On n'affiche les commentaires postés par des utilisateurs bannis qu'à ces utilisateurs eux-mêmes.
            if COMMENTS_BANNED_USERS_GROUP:
                comment_list = [c for c in comment_list if not c.is_hidden or (user_id == c.user_id)]

        context[self.var_name] = comment_list
        return ''

class DoCommentForm:
    """
    Affiche un formulaire permettant d'ajouter un commentaire; le formulaire est généré à partir des paramètres spécifiés. Syntaxe :
        {% comment_form for [paquet].[nom_du_module_py] [var_du_contexte_contenant_id_de_l_objet] with [liste d'options] %}
    Exemple :
        {% comment_form for lcom.evenements evenement.id with is_public yes photos_optional thumbs,200,400 ratings_optional scale:1-5|premiere_option|deuxieme_option %}
    [var_du_contexte_contenant_id_de_l_objet] peut être un entier codé en dur ou le nom d'une variable contenant l'identifiant.
    """
    def __init__(self, free, tag_name):
        self.free, self.tag_name = free, tag_name

    def __call__(self, parser, token):
        tokens = token.contents.split()
        if len(tokens) < 4:
            raise template.TemplateSyntaxError, "La balise '%s' nécessite au moins 3 arguments" % self.tag_name
        if tokens[1] != 'for':
            raise template.TemplateSyntaxError, "Le deuxième argument de la balise '%s' doit être 'for'" % self.tag_name
        try:
            package, module = tokens[2].split('.')
        except ValueError: # la liste à droite de l'affectation n'a pas la bonne taille
            raise template.TemplateSyntaxError, "Le troisième argument de la balise '%s' doit être de la forme 'paquet.module'" % self.tag_name
        try:
            content_type = contenttypes.get_object(package__label__exact=package, python_module_name__exact=module)
        except contenttypes.ContentTypeDoesNotExist:
            raise template.TemplateSyntaxError, "La balise '%s' s'est vu associer un type de contenu invalide : '%s.%s'" % (self.tag_name, package, module)
        obj_id_lookup_var, obj_id = None, None
        if tokens[3].isdigit():
            obj_id = tokens[3]
            try: # on s'assure de la validité de l'identifiant de l'objet
                content_type.get_object_for_this_type(id__exact=obj_id)
            except ObjectDoesNotExist:
                raise template.TemplateSyntaxError, "La balise '%s' fait référence à un objet de type '%s' dont l'identifiant est %s; or, cet objet n'existe pas" % (self.tag_name, content_type.name, obj_id)
        else:
            obj_id_lookup_var = tokens[3]
        kwargs = {}
        if len(tokens) > 4:
            if tokens[4] != 'with':
                raise template.TemplateSyntaxError, "Le quatrième argument de la balise '%s' doit être 'with'" % self.tag_name
            for option, args in zip(tokens[5::2], tokens[6::2]):
                if option in ('photos_optional', 'photos_required') and not self.free:
                    # VALIDATION ##############################################
                    option_list = args.split(',')
                    if len(option_list) % 3 != 0:
                        raise template.TemplateSyntaxError, "La balise '%s' s'est vu passer une liste d'arguments séparés par des virgules de taille incorrecte" % self.tag_name
                    for opt in option_list[::3]:
                        if not opt.isalnum():
                            raise template.TemplateSyntaxError, "La balise '%s' contient un nom de répertoire pour les photos qui est invalide : '%s'" % (self.tag_name, opt)
                    for opt in option_list[1::3] + option_list[2::3]:
                        if not opt.isdigit() or not (comments.MIN_PHOTO_DIMENSION <= int(opt) <= comments.MAX_PHOTO_DIMENSION):
                            raise template.TemplateSyntaxError, "La balise '%s' contient des dimensions pour les photos qui sont invalides  : '%s'. Seules des valeurs entre %s et %s sont autorisées." % (self.tag_name, opt, comments.MIN_PHOTO_DIMENSION, comments.MAX_PHOTO_DIMENSION)
                    # FIN DE LA VALIDATION ####################################
                    kwargs[option] = True
                    kwargs['photo_options'] = args
                elif option in ('ratings_optional', 'ratings_required') and not self.free:
                    # VALIDATION ##############################################
                    if 2 < len(args.split('|')) > 9:
                        raise template.TemplateSyntaxError, "Le nombre d'options pour '%s' passées à la balise '%s' est incorrect. Vous pouvez spécifier entre 2 et 8 options." % (option, self.tag_name)
                    if re.match('^scale:\d+\-\d+\:$', args.split('|')[0]):
                        raise template.TemplateSyntaxError, "L'argument 'scale' associé à l'une des options pour '%s' dans la balise '%s' est invalide" % (option, self.tag_name)
                    # FIN DE LA VALIDATION ####################################
                    kwargs[option] = True
                    kwargs['rating_options'] = args
                elif option in ('is_public'):
                    kwargs[option] = (args == 'true')
                else:
                    raise template.TemplateSyntaxError, "La balise '%s' s'est vu passer un paramètre invalide : '%s'" % (self.tag_name, option)
        return CommentFormNode(content_type, obj_id_lookup_var, obj_id, self.free, **kwargs)

class DoCommentCount:
    """
    Obtient le nombre de commentaires correspondant aux paramètres spécifiés; le
    contexte du modèle est ensuite modifié pour inclure une variable contenant la
    valeur ainsi obtenue; le nom de cette variable est défini par la clause 'as'.
    Syntaxe :
        {% get_comment_count for [paquet].[nom_du_module_py] [var_du_contexte_contenant_id_de_l_objet] as [nom_variable] %}
    Exemple :
        {% get_comment_count for lcom.evenements evenement.id as nombre_commentaires %}
    Note : [var_du_contexte_contenant_id_de_l_objet] peut aussi être un entier codé en dur, comme dans l'exemple suivant :
        {% get_comment_count for lcom.evenements 23 as nombre_commentaires %}
    """
    def __init__(self, free, tag_name):
        self.free, self.tag_name = free, tag_name

    def __call__(self, parser, token):
        tokens = token.contents.split()
        # La variable tokens est maintenant une liste du style :
        # ['get_comment_list', 'for', 'lcom.evenements', 'evenement.id', 'as', 'liste_de_commentaires']
        if len(tokens) != 6:
            raise template.TemplateSyntaxError, "La balise-bloc %s nécessite 5 arguments" % self.tag_name
        if tokens[1] != 'for':
            raise template.TemplateSyntaxError, "Le deuxième argument de la balise '%s' doit être 'for'" % self.tag_name
        try:
            package, module = tokens[2].split('.')
        except ValueError: # la liste à droite de l'affectation n'a pas la bonne taille
            raise template.TemplateSyntaxError, "Le troisième argument de la balise '%s' doit être de la forme 'paquet.module'" % self.tag_name
        try:
            content_type = contenttypes.get_object(package__label__exact=package, python_module_name__exact=module)
        except contenttypes.ContentTypeDoesNotExist:
            raise template.TemplateSyntaxError, "La balise '%s' s'est vu associer un type de contenu invalide : '%s.%s'" % (self.tag_name, package, module)
        var_name, obj_id = None, None
        if tokens[3].isdigit():
            obj_id = tokens[3]
            try: # on s'assure de la validité de l'identifiant de l'objet
                content_type.get_object_for_this_type(id__exact=obj_id)
            except ObjectDoesNotExist:
                raise template.TemplateSyntaxError, "La balise '%s' fait référence à un objet de type '%s' dont l'identifiant est %s; or, cet objet n'existe pas" % (self.tag_name, content_type.name, obj_id)
        else:
            var_name = tokens[3]
        if tokens[4] != 'as':
            raise template.TemplateSyntaxError, "Le quatrième argument de la balise '%s' doit être 'as'" % self.tag_name
        return CommentCountNode(package, module, var_name, obj_id, tokens[5], self.free)

class DoGetCommentList:
    """
    Obtient les commentaires correspondant aux paramètres spécifiés; le contexte
    du modèle est ensuite modifié pour inclure une variable particulière contenant
    la valeur ainsi obtenue; le nom de cette variable est défini par la clause 'as'.
    Syntaxe :
        {% get_comment_list for [paquet].[nom_du_module_py] [var_du_contexte_contenant_id_de_l_objet] as [nom_variable] %}
    Exemple :
        {% get_comment_list for lcom.evenements evenement.id as liste_de_commentaires %}
    Note : [var_du_contexte_contenant_id_de_l_objet] peut aussi être un entier codé en dur, comme dans l'exemple suivant :
        {% get_comment_list for lcom.evenements 23 as liste_de_commentaires %}
    """
    def __init__(self, free, tag_name):
        self.free, self.tag_name = free, tag_name

    def __call__(self, parser, token):
        tokens = token.contents.split()
        # La variable tokens est maintenant une liste du style :
        # ['get_comment_list', 'for', 'lcom.evenements', 'evenement.id', 'as', 'liste_de_commentaires']
        if len(tokens) != 6:
            raise template.TemplateSyntaxError, "La balise-bloc %s nécessite 5 arguments" % self.tag_name
        if tokens[1] != 'for':
            raise template.TemplateSyntaxError, "Le deuxième argument de la balise '%s' doit être 'for'" % self.tag_name
        try:
            package, module = tokens[2].split('.')
        except ValueError: # la liste à droite de l'affectation n'a pas la bonne taille
            raise template.TemplateSyntaxError, "Le troisième argument de la balise '%s' doit être de la forme 'paquet.module'" % self.tag_name
        try:
            content_type = contenttypes.get_object(package__label__exact=package, python_module_name__exact=module)
        except contenttypes.ContentTypeDoesNotExist:
            raise template.TemplateSyntaxError, "La balise '%s' s'est vu associer un type de contenu invalide : '%s.%s'" % (self.tag_name, package, module)
        var_name, obj_id = None, None
        if tokens[3].isdigit():
            obj_id = tokens[3]
            try: # on s'assure de la validité de l'identifiant de l'objet
                content_type.get_object_for_this_type(id__exact=obj_id)
            except ObjectDoesNotExist:
                raise template.TemplateSyntaxError, "La balise '%s' fait référence à un objet de type '%s' dont l'identifiant est %s; or, cet objet n'existe pas" % (self.tag_name, content_type.name, obj_id)
        else:
            var_name = tokens[3]
        if tokens[4] != 'as':
            raise template.TemplateSyntaxError, "Le quatrième argument de la balise '%s' doit être 'as'" % self.tag_name
        return CommentListNode(package, module, var_name, obj_id, tokens[5], self.free)

# pour les commentaires postés par des utilisateurs inscrits
template.register_tag('get_comment_list',       DoGetCommentList(free=False, tag_name='get_comment_list'))
template.register_tag('comment_form',           DoCommentForm(free=False, tag_name='comment_form'))
template.register_tag('get_comment_count',      DoCommentCount(free=False, tag_name='get_comment_count'))
# pour les commentaires libres
template.register_tag('get_free_comment_list',  DoGetCommentList(free=True, tag_name='get_free_comment_list'))
template.register_tag('free_comment_form',      DoCommentForm(free=True, tag_name='free_comment_form'))
template.register_tag('get_free_comment_count', DoCommentCount(free=True, tag_name='get_free_comment_count'))
